import { app, BrowserWindow, BrowserView, ipcMain, session, Tray, Menu, nativeImage } from 'electron';
import path, { join } from 'path';
import { electronApp, is } from '@electron-toolkit/utils';
import icon from '../../resources/icon.png?asset';
const fs = require('fs');
const { mkdirSync } = require('fs');
const { networkInterfaces } = require('os');

// 导入完整性检查工具
import { initIntegrityCheck, verifyApplicationIntegrity } from '../utils/integrityChecker';

app.commandLine.appendSwitch('ignore-certificate-errors', 'true');
// 启用扩展支持
app.commandLine.appendSwitch('enable-features', 'ExtensionsToolbarMenu');
app.commandLine.appendSwitch('allow-insecure-localhost', 'true');
app.commandLine.appendSwitch('ignore-certificate-errors-spki-list');

// 应用启动时进行完整性检查
const appPath = app.getAppPath();
// 初始化完整性检查，首次运行时生成文件哈希清单
initIntegrityCheck(appPath);

// 验证应用完整性
const integrityResult = verifyApplicationIntegrity(appPath);
if (!integrityResult.valid) {
  console.error('应用完整性检查失败，检测到以下文件被修改:', integrityResult.modifiedFiles);
  // 在生产环境中可以选择退出应用
  // if (!is.dev) {
  //   app.exit(1);
  // }
}

// 获取用户数据目录
const userDataPath = app.getPath('userData');
// 确保存储 tabs.json 的目录存在
const tabsDir = path.join(userDataPath, 'tabs');
try {
  mkdirSync(tabsDir, { recursive: true });
} catch (error) {
  console.error('❌ 创建目录失败:', error);
}

// 全局变量
let mainWindow;
const views = [];
let currentViewIndex = -1;
const tabsFilePath = path.join(tabsDir, 'tabs.json');
console.log('tabsFilePath: ', tabsFilePath);

// 获取MAC地址
const getMacAddress = () => {
  try {
    const interfaces = networkInterfaces();
    for (const name of Object.keys(interfaces)) {
      for (const iface of interfaces[name]) {
        // 跳过内部接口和非IPv4接口
        if (!iface.internal && iface.family === 'IPv4') {
          return iface.mac;
        }
      }
    }
    return null;
  } catch (error) {
    console.error('获取MAC地址失败:', error);
    return null;
  }
};

// 读取本地存储的标签页数据
const loadTabs = () => {
  if (fs.existsSync(tabsFilePath)) {
    try {
      const data = JSON.parse(fs.readFileSync(tabsFilePath, 'utf-8'));
      console.log('data_loadTabs: ', data);
      return data;
    } catch (error) {
      console.error('❌ 读取 tabs.json 失败:', error);
      return [];
    }
  }
  return [];
};

// 保存标签页信息
const saveTabs = async (tabArr) => {
  let tabData = [];
  console.log('views111: ', JSON.stringify(views));
  tabData = tabArr;

  fs.writeFileSync(tabsFilePath, JSON.stringify(tabData, null, 2), 'utf-8');
  console.log('Tabs saved with the new structure');
  return tabData;
};

// 获取所有 Cookie
const getCookies = async (view) => {
  const cookies = await view.webContents.session.cookies.get({});
  return cookies;
};

// 创建 BrowserWindow
const createWindow = () => {
  mainWindow = new BrowserWindow({
    width: 1500,
    height: 800,
    autoHideMenuBar: true, // 改为 false 显示菜单栏，扩展图标可能在附近
    icon: icon,
    ...(process.platform === 'linux' ? { icon } : {}),
    webPreferences: {
      preload: join(__dirname, '../preload/index.js'),
      sandbox: false,
      nodeIntegration: false,
      contextIsolation: true,
      backgroundThrottling: false, // 禁用后台页面节流
      cache: false, // 禁用缓存
      webSecurity: false, // 禁用web安全策略以允许跨域请求
      // allowRunningInsecureContent: true, // 允许加载不安全的内容
    },
    title: 'Whatsapp多开翻译助手',
  });
  if (is.dev) {
    mainWindow.webContents.openDevTools({ mode: 'detach' });
  }

  mainWindow.on('resize', () => {
    resizeViews();
  });

  // 监听窗口最大化和恢复正常大小事件
  mainWindow.on('maximize', () => {
    resizeViews();
  });

  mainWindow.on('unmaximize', () => {
    resizeViews();
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  // 加载主窗口内容
  if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
    mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL']);
  } else {
    mainWindow.loadFile(join(__dirname, '../renderer/index.html'));
  }

  // 修改 CSP 以允许从特定源加载资源
  mainWindow.webContents.session.webRequest.onHeadersReceived((details, callback) => {
    callback({
      responseHeaders: {
        ...details.responseHeaders,
        'Content-Security-Policy': [
          "default-src 'self'; connect-src 'self' https://wsapp.globalshhop.top; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data:",
        ],
      },
    });
  });

  // 监听登录状态变化，只有登录后才加载tabs
  mainWindow.webContents.on('did-finish-load', () => {
    // 监听localStorage变化，检测登录状态
    mainWindow.webContents.executeJavaScript(`
      window.addEventListener('storage', (event) => {
        if (event.key === 'token') {
          // 通知主进程登录状态变化
          if (window.api) {
            window.api.loginStatusChanged(event.newValue ? true : false);
          }
        }
      });
      
      // 初始检查登录状态
      const isLoggedIn = !!localStorage.getItem('token');
      if (window.api) {
        window.api.loginStatusChanged(isLoggedIn);
      }
    `);
  });

  if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
    mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL']);
  } else {
    mainWindow.loadFile(join(__dirname, '../renderer/index.html'));
  }
};

// 创建新的 BrowserView 作为 tab
const createBrowserView = async (url, partition) => {
  console.log('partition11: ', partition);
  console.log('views: ', JSON.stringify(views));

  // 扩展加载路径检查 - 确保在开发和生产环境都能正确找到扩展
  let extensionPath;
  if (is.dev) {
    console.log('is.dev: ', is.dev);

    extensionPath = path.join(__dirname, '../../resources/fanyi2');
  } else {
    // 在生产环境中，app.getAppPath()返回的是asar文件的路径
    // 需要使用app.getPath('exe')获取可执行文件路径，然后找到解包的资源
    const exePath = app.getPath('exe');
    const exeDir = path.dirname(exePath);
    extensionPath = path.join(exeDir, 'resources/app.asar.unpacked/resources/fanyi2');
  }
  console.log('extensionPath: ', extensionPath);
  if (!fs.existsSync(extensionPath)) {
    console.error('扩展目录不存在:', extensionPath);
    return null;
  }

  // 确保partition值有效
  if (!partition) {
    partition = `tab${views.length + 1}_${Date.now()}`;
  }

  // 使用持久化会话而不是临时会话，确保扩展可以正常加载
  // 注意：partition字符串前面加上'persist:'前缀表示这是一个持久化会话
  const viewSession = session.fromPartition('persist:' + partition);
  viewSession.setCertificateVerifyProc((request, callback) => {
    callback(0); // Accept all certificates
  });

  // 设置权限
  viewSession.setPermissionRequestHandler((webContents, permission, callback) => {
    callback(true); // 允许所有权限
  });
  // 加载本地扩展
  try {
    // 使用与扩展路径检查相同的路径解析方式加载扩展
    const extension = await viewSession.loadExtension(extensionPath, {
      allowFileAccess: true, // 允许文件访问
      manifestV2: true,
      // 添加扩展初始化配置
      initPreferences: {
        fixSetting: true,
        enableBackground: true,
      },
    });
    console.log('extension: ', extension);

    // 打印扩展信息
    // console.log('扩展加载成功:', extension.name, extension.version);
    // 获取所有已加载的扩展
    // const extensions = viewSession.getAllExtensions();
    // console.log('load all extensions:', extensions);
  } catch (error) {
    console.log('error_fanyi: ', error);
  }

  // 保存完整的partition值，包括'persist:'前缀
  const fullPartition = 'persist:' + partition;

  const view = new BrowserView({
    webPreferences: {
      session: viewSession,
      partition: fullPartition, // 使用完整的partition值
      nodeIntegration: false,
      contextIsolation: true,
      preload: path.join(__dirname, '../preload/index.js'),
      backgroundThrottling: false, // 禁用后台页面节流
      cache: false, // 禁用缓存
      webSecurity: false, // 关闭 Web 安全以允许加载翻译脚本
      allowRunningInsecureContent: true, // 关闭 Web 安全以允许加载翻译脚本
      experimentalFeatures: false, // 关闭实验性功能
      webviewTag: true, // 启用 webview 支持
      sandbox: false, // 关闭沙箱以支持扩展
      extensions: true, // 启用扩展支持
    },
  });

  // 存储额外信息到view对象，便于调试
  view.partitionInfo = partition;

  // 添加右键菜单
  view.webContents.on('context-menu', () => {
    const menu = require('electron').Menu.buildFromTemplate([
      {
        label: '刷新',
        click: () => {
          view.webContents.reload();
        },
      },
    ]);
    menu.popup();
  });
  view.webContents.setUserAgent(
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
  );

  view.webContents.once('did-finish-load', () => {
    view.webContents.reload();
  });

  // 在恢复cookie后再加载URL
  view.webContents.loadURL(url);

  mainWindow.addBrowserView(view);
  views.push(view);

  if (views.length === 1) {
    switchToTab(0);
  }

  // 打开单独view开发者工具tabs
  // view.webContents.openDevTools({ mode: 'detach' });

  const [width, height] = mainWindow.getContentSize();
  view.setBounds({ x: 205, y: 0, width: width - 205, height: height });

  return views.length - 1;
};

// 切换 BrowserView
const switchToTab = (index) => {
  console.log('index_switchToTab: ', index);
  // 确保 index 在 views 数组的有效范围内
  if (index < 0 || index >= views.length) return;
  currentViewIndex = index;
  mainWindow.setBrowserView(views[index]);
  const [width, height] = mainWindow.getContentSize();
  views[index].setBounds({ x: 205, y: 0, width: width - 205, height: height });
  views[index].setAutoResize({ width: true, height: true });

  // 自动清除该视图的新消息状态
  // 查找对应的tabIndex和urlIndex
  for (const key in messageStatus) {
    if (messageStatus[key]) {
      const [tabIndex, urlIndex] = key.split('_').map(Number);
      const viewIndex = tabIndex * 2 + urlIndex;
      if (viewIndex === index) {
        // 清除消息状态
        messageStatus[key] = false;
        console.log(`自动清除标签页 ${tabIndex} 子标签 ${urlIndex} 的新消息状态`);
        // 通知渲染进程更新UI
        mainWindow.webContents.send('message-status-cleared', tabIndex, urlIndex);
      }
    }
  }
};

// 重新设置所有 BrowserView 的布局
const resizeViews = () => {
  const [width, height] = mainWindow.getContentSize();
  views.forEach((view, id) => {
    if (id === currentViewIndex) {
      view.setBounds({
        x: 205,
        y: 0,
        width: width - 205,
        height: height,
      });
      view.setAutoResize({ width: true, height: true });
    } else {
      view.setBounds({ x: 205, y: 0, width: 0, height: 0 });
    }
  });
};

// 监听 Storage 变化，并存储
ipcMain.on('session-changed', async (event, localStorageData, sessionStorageData) => {
  // 获取发送事件的webContents
  const senderWebContents = event.sender;
  const tabs = loadTabs();

  // 查找对应的视图索引
  const tabIndex = views.findIndex((v) => v.webContents.id === senderWebContents.id);

  console.log('session-changed from webContents ID:', senderWebContents.id);
  console.log(
    'Current views IDs:',
    views.map((v) => v.webContents.id),
  );
  console.log('Found tabIndex:', tabIndex);

  if (tabIndex !== -1) {
    // 获取当前视图
    const view = views[tabIndex];
    const partition = view.webContents.session.partition;

    // 获取最新的cookies
    const currentCookies = await getCookies(view);

    // 解析localStorage和sessionStorage数据
    let parsedLocalStorage = {};
    let parsedSessionStorage = {};

    try {
      parsedLocalStorage = JSON.parse(localStorageData);
    } catch (error) {
      console.error('Failed to parse localStorage data:', error);
    }

    try {
      parsedSessionStorage = JSON.parse(sessionStorageData);
    } catch (error) {
      console.error('Failed to parse sessionStorage data:', error);
    }

    // 查找对应partition的标签页，如果不存在则创建新的
    const tabDataIndex = tabs.findIndex((tab) => tab.partition === partition);

    if (tabDataIndex === -1) {
      // 如果没有找到对应的标签页数据，创建新的
      tabs.push({
        url: view.webContents.getURL(),
        title: `persist:tab${tabIndex + 1}`,
        partition: partition,
        sessionData: {
          cookies: currentCookies,
          localStorage: parsedLocalStorage,
          sessionStorage: parsedSessionStorage,
        },
      });
    } else {
      // 更新现有标签页的会话数据
      tabs[tabDataIndex].sessionData = {
        cookies: currentCookies,
        localStorage: parsedLocalStorage,
        sessionStorage: parsedSessionStorage,
      };
    }

    console.log(`Saving session data for tab ${tabIndex}`);
    fs.writeFileSync(tabsFilePath, JSON.stringify(tabs, null, 2), 'utf-8');
  }
});

// 创建 `BrowserView`
ipcMain.handle('create-browser-view', async (_, url = '', partition = null) => {
  const partitionName = partition || `tab_${Date.now()}`;
  return createBrowserView(url, partitionName);
});
ipcMain.handle('save-tabs', async (_, tabArr) => {
  return saveTabs(tabArr);
});

// 让前端 index.html 也能访问存储的 tabs
ipcMain.handle('load-tabs', async () => {
  // 检查登录状态，只有登录后才返回tabs数据
  const isLoggedIn = global.isLoggedIn || false;
  if (isLoggedIn) {
    const storedTabs = loadTabs();
    // 确保 storedTabs 中的 urls 包含正确的 index
    storedTabs.forEach((tab) => {
      tab.urls.forEach((urlObj, urlIndex) => {
        urlObj.index = tab.index * 2 + urlIndex;
      });
    });
    return storedTabs; // 读取本地 tabs.json 数据并返回
  } else {
    return []; // 未登录时返回空数组
  }
});

// 处理登录状态变化
ipcMain.on('login-status-changed', (_, isLoggedIn) => {
  console.log('isLoggedIn: ', isLoggedIn);
  global.isLoggedIn = isLoggedIn;

  // 如果已登录且没有加载tabs，则加载tabs
  if (isLoggedIn && views.length === 0) {
    const storedTabs = loadTabs();
    console.log('登录后加载标签页:', storedTabs);
    if (storedTabs.length > 0) {
      storedTabs.forEach((tabObj) => {
        tabObj.urls.forEach((tab) => {
          console.log('tab0000: ', tab);
          createBrowserView(tab.url, tab.partition);
        });
      });
      // 保存标签页信息
      saveTabs(storedTabs);
    }
  } else if (!isLoggedIn && views.length > 0) {
    // 如果退出登录，清除所有已加载的tabs
    console.log('退出登录，清除所有标签页');
    for (let i = views.length - 1; i >= 0; i--) {
      const viewToRemove = views[i];
      mainWindow.removeBrowserView(viewToRemove);
    }
    views.length = 0;
    currentViewIndex = -1;
  }
});

// 获取MAC地址
ipcMain.handle('get-mac-address', () => {
  return getMacAddress();
});

// 检查MAC地址授权状态
ipcMain.handle('check-mac-authorization', () => {
  const macAddress = getMacAddress();
  // 这里可以实现更复杂的授权逻辑，例如从远程服务器验证
  // 目前简单返回MAC地址，前端会使用authService进行验证
  return macAddress;
});

// 获取用户数据目录路径
ipcMain.handle('get-user-data-path', () => {
  return app.getPath('userData');
});

// 用于调试的函数，返回views数组的详细信息
ipcMain.handle('debug-views', () => {
  try {
    // 返回views数组的关键信息
    return views.map((view, index) => {
      // 尝试获取分区信息
      let partition = '';
      try {
        // 首先检查我们自定义的partitionInfo属性
        if (view.partitionInfo) {
          partition = view.partitionInfo;
        } else {
          // 然后尝试从session对象获取partition
          partition = view.webContents.session.partition || '';

          // 如果获取到的partition包含'persist:'前缀，去掉它以保持一致性
          if (partition.startsWith('persist:')) {
            partition = partition.substring(8);
          }

          // 如果还是没有获取到，尝试从webPreferences中获取
          if (!partition && view.webPreferences) {
            partition = view.webPreferences.partition || '';

            // 同样去掉可能的'persist:'前缀
            if (partition.startsWith('persist:')) {
              partition = partition.substring(8);
            }
          }
        }
      } catch (err) {
        console.error('获取partition失败:', err);
      }

      return {
        index,
        url: view.webContents.getURL(),
        id: view.webContents.id,
        partition: partition,
        sessionPartition: view.webContents.session.partition || '未知',
        // 添加更多可能有用的信息
        title: view.webContents.getTitle(),
        webContentsId: view.webContents.id,
      };
    });
  } catch (error) {
    console.error('获取views数组信息出错:', error);
    return [];
  }
});

// 切换 `BrowserView`
ipcMain.on('switch-browser-view', (_, index) => {
  switchToTab(index);
});

// WhatsApp消息监听相关功能
// 存储每个标签页的消息状态和定时器ID
const messageStatus = {};
const messageTimers = {};
// 存储消息检查状态，用于跟踪连续未检测到消息的次数
const messageCheckState = {};
// 存储未读消息数量
const unreadCounts = {};
let totalUnreadCount = 0; // 总未读消息数量

// 更新任务栏图标上的未读消息数量
const updateTaskbarIcon = () => {
  // 重新计算总未读消息数量
  totalUnreadCount = Object.values(unreadCounts).reduce((sum, current) => sum + current, 0);

  if (process.platform === 'darwin') {
    // macOS
    app.setBadgeCount(totalUnreadCount);
  } else if (process.platform === 'win32' && mainWindow) {
    // Windows - 使用setOverlayIcon
    if (totalUnreadCount > 0) {
      try {
        // 使用Node.js的canvas模块创建图像
        const { createCanvas } = require('canvas');
        const canvas = createCanvas(16, 16);
        const ctx = canvas.getContext('2d');

        // 绘制红色圆形背景
        ctx.beginPath();
        ctx.fillStyle = 'red';
        ctx.arc(8, 8, 8, 0, 2 * Math.PI);
        ctx.fill();

        // 绘制白色文本
        ctx.fillStyle = 'white';
        ctx.font = 'bold 11px Arial';
        ctx.textAlign = 'center';
        ctx.textBaseline = 'middle';

        // 根据数字位数调整显示
        let displayCount = totalUnreadCount;
        if (totalUnreadCount > 99) {
          displayCount = '99+';
        }

        ctx.fillText(displayCount.toString(), 8, 8);

        // 将canvas转换为图像
        const nativeImage = require('electron').nativeImage.createFromDataURL(canvas.toDataURL());

        // 设置任务栏图标
        mainWindow.setOverlayIcon(nativeImage, `${totalUnreadCount}条未读消息`);
      } catch (error) {
        console.error('创建任务栏图标失败:', error);
        // 如果canvas模块不可用，尝试使用简单的红点图标
        try {
          // 创建一个简单的红点图标
          const size = 16;
          const nativeImage = require('electron').nativeImage.createEmpty();
          const emptyBitmap = Buffer.alloc(size * size * 4);

          // 填充红色圆点
          for (let y = 0; y < size; y++) {
            for (let x = 0; x < size; x++) {
              const dx = x - size / 2;
              const dy = y - size / 2;
              const distance = Math.sqrt(dx * dx + dy * dy);

              if (distance <= size / 2) {
                // 红色圆点 (RGBA: 255, 0, 0, 255)
                const offset = (y * size + x) * 4;
                emptyBitmap[offset] = 255; // R
                emptyBitmap[offset + 1] = 0; // G
                emptyBitmap[offset + 2] = 0; // B
                emptyBitmap[offset + 3] = 255; // A
              }
            }
          }

          nativeImage.addRepresentation({
            width: size,
            height: size,
            buffer: emptyBitmap,
            scaleFactor: 1.0,
          });

          mainWindow.setOverlayIcon(nativeImage, `${totalUnreadCount}条未读消息`);
        } catch (fallbackError) {
          console.error('创建简单图标也失败:', fallbackError);
        }
      }
    } else {
      // 清除任务栏图标
      mainWindow.setOverlayIcon(null, '');
    }
  }
};

// 开始监听WhatsApp消息
ipcMain.on('start-message-monitoring', (_, tabIndex, urlIndex) => {
  const viewIndex = tabIndex * 2 + urlIndex; // 计算实际的view索引
  if (viewIndex >= 0 && viewIndex < views.length) {
    const view = views[viewIndex];
    // 注入监听脚本到WhatsApp页面
    view.webContents
      .executeJavaScript(
        `
      (function() {
        // 创建一个消息监听器
        if (!window._messageObserver) {
          // 定义一个函数来获取未读消息数量
          window._getUnreadCount = function() {
            // 获取具有指定类名的父元素，消息个数的父元素
            const parentElement = document.querySelector('.x1oozmrk');
            let count = 0;
            let hasNewMessage = false;
            
            if (parentElement) {
              hasNewMessage = true;
              // 在父元素下查找 span 元素，里面存在未读用户的数量
              const spanElement = parentElement.querySelector('span');
              if (spanElement) {
                // 获取 span 元素的文本内容
                const text = spanElement.textContent.trim();
                // 尝试将文本转换为数字
                const parsedCount = parseInt(text, 10);
                if (!isNaN(parsedCount)) {
                  count = parsedCount;
                } else {
                  // 如果无法解析为数字，至少有一条消息
                  count = 1;
                }
              } else {
                // 如果找不到span元素但有未读指示器，至少有一条消息
                count = 1;
              }
            }
            
            return { hasNewMessage, count };
          };
          
          // 使用MutationObserver监听DOM变化
          window._messageObserver = new MutationObserver(function(mutations) {
            // 获取未读消息状态和数量
            const { hasNewMessage, count } = window._getUnreadCount();
            // 通知主进程消息状态变化
            if (window.api && window.api.updateMessageStatus) {
              window.api.updateMessageStatus(hasNewMessage, ${tabIndex}, ${urlIndex}, count);
            }
          });
          
          // 立即检查一次当前状态
          const initialState = window._getUnreadCount();
          if (window.api && window.api.updateMessageStatus) {
            window.api.updateMessageStatus(initialState.hasNewMessage, ${tabIndex}, ${urlIndex}, initialState.count);
          }
          
          // 开始观察整个文档的变化
          window._messageObserver.observe(document.body, {
            childList: true,
            subtree: true,
            attributes: true,
            attributeFilter: ['class']
          });
          
          console.log('WhatsApp消息监听已启动');
        }
        return true;
      })();
    `,
      )
      .catch((err) => console.error('启动消息监听失败:', err));

    // 设置定时轮询，每2秒检查一次消息状态
    const key = `${tabIndex}_${urlIndex}`;
    // 清除可能存在的旧定时器
    if (messageTimers[key]) {
      clearInterval(messageTimers[key]);
    }

    // 创建新的定时器
    // 添加一个变量来跟踪连续未检测到消息的次数
    const messageCheckState = {};
    messageCheckState[key] = { consecutiveNoMessageCount: 0, lastMessageState: false };

    messageTimers[key] = setInterval(() => {
      // 检查view是否仍然存在于views数组中，以及webContents是否可用
      if (view && views.includes(view) && view.webContents && !view.webContents.isDestroyed()) {
        view.webContents
          .executeJavaScript(
            `
          (function() {
            // 使用之前定义的函数获取未读消息状态和数量
            if (window._getUnreadCount) {
              const result = window._getUnreadCount();
              // 通知主进程消息状态变化
              if (window.api && window.api.updateMessageStatus) {
                window.api.updateMessageStatus(result.hasNewMessage, ${tabIndex}, ${urlIndex}, result.count);
              }
              return result;
            } else {
              // 如果函数不存在，使用旧方法
              const hasNewMessage = document.querySelector('.x10l6tqk.x14ipxcb.x1oozmrk') !== null;
              // 获取具有指定类名的父元素
              const parentElement = document.querySelector('.x10l6tqk.x14ipxcb.x1oozmrk');
              let count = 0;
              
              if(parentElement){
                // 在父元素下查找 span 元素
                const spanElement = parentElement.querySelector('span');
                if (spanElement) {
                  // 获取 span 元素的文本内容
                  const text = spanElement.textContent.trim();
                  console.log('spanElement text:', text);
                  // 尝试将文本转换为数字
                  const parsedCount = parseInt(text, 10);
                  if (!isNaN(parsedCount)) {
                    count = parsedCount;
                  } else {
                    count = 1;
                  }
                } else {
                  count = 1;
                }
              }
              
              // 通知主进程消息状态变化
              if (window.api && window.api.updateMessageStatus) {
                window.api.updateMessageStatus(hasNewMessage, ${tabIndex}, ${urlIndex}, count);
              }
              return { hasNewMessage, count };
            }
          })();
        `,
          )
          .then((result) => {
            const hasNewMessage = result.hasNewMessage;
            // const count = result.count || 0;
            // 如果之前有消息，现在没有消息，则认为消息已读
            if (messageCheckState[key].lastMessageState && !hasNewMessage) {
              // 增加连续未检测到消息的计数
              messageCheckState[key].consecutiveNoMessageCount++;

              // 如果连续两次未检测到消息，则认为消息已读
              if (messageCheckState[key].consecutiveNoMessageCount >= 1) {
                console.log(`标签页 ${tabIndex} 的消息已读，自动清除消息状态`);
                // 清除消息状态
                messageStatus[key] = false;
                // 通知渲染进程消息状态已清除
                mainWindow.webContents.send('message-status-cleared', tabIndex, urlIndex);
                // 重置计数
                messageCheckState[key].consecutiveNoMessageCount = 0;
              }
            } else if (hasNewMessage) {
              // 如果检测到消息，重置计数
              messageCheckState[key].consecutiveNoMessageCount = 0;
            }

            // 更新上次消息状态
            messageCheckState[key].lastMessageState = hasNewMessage;
          })
          .catch((err) => console.error('定时检查消息状态失败:', err));
      }
    }, 2000); // 每2秒执行一次
  }
});

// 停止监听WhatsApp消息
ipcMain.on('stop-message-monitoring', (_, tabIndex, urlIndex) => {
  const viewIndex = tabIndex * 2 + urlIndex;
  if (viewIndex >= 0 && viewIndex < views.length) {
    const view = views[viewIndex];
    view.webContents
      .executeJavaScript(
        `
      (function() {
        if (window._messageObserver) {
          window._messageObserver.disconnect();
          window._messageObserver = null;
          console.log('WhatsApp消息监听已停止');
        }
        return true;
      })();
    `,
      )
      .catch((err) => console.error('停止消息监听失败:', err));
  }

  // 清除该标签页的消息状态和定时器
  const key = `${tabIndex}_${urlIndex}`;
  if (messageStatus[key]) {
    delete messageStatus[key];
  }

  // 清除消息检查状态
  if (messageCheckState && messageCheckState[key]) {
    delete messageCheckState[key];
  }

  // 清除定时器
  if (messageTimers[key]) {
    clearInterval(messageTimers[key]);
    delete messageTimers[key];
    console.log(`标签页 ${tabIndex} 的定时消息检查已停止`);
  }
});

// 更新消息状态
ipcMain.on('update-message-status', (_, hasNewMessage, tabIndex, urlIndex, count = 0) => {
  const key = `${tabIndex}_${urlIndex}`;
  const oldStatus = messageStatus[key] || false;
  const oldCount = unreadCounts[key] || 0;

  // 更新状态和未读数量
  messageStatus[key] = hasNewMessage;
  unreadCounts[key] = hasNewMessage ? count : 0;

  // 计算总未读消息数量
  totalUnreadCount = Object.values(unreadCounts).reduce((sum, current) => sum + current, 0);

  // 更新任务栏图标上的未读消息数量
  if (process.platform === 'darwin') {
    // macOS
    app.setBadgeCount(totalUnreadCount);
  } else if (process.platform === 'win32' && mainWindow) {
    // Windows - 使用setOverlayIcon
    if (totalUnreadCount > 0) {
      try {
        // 使用Node.js的canvas模块创建图像
        const { createCanvas } = require('canvas');
        const canvas = createCanvas(16, 16);
        const ctx = canvas.getContext('2d');

        // 绘制红色圆形背景
        ctx.beginPath();
        ctx.fillStyle = 'red';
        ctx.arc(8, 8, 8, 0, 2 * Math.PI);
        ctx.fill();

        // 绘制白色文本
        ctx.fillStyle = 'white';
        ctx.font = 'bold 11px Arial';
        ctx.textAlign = 'center';
        ctx.textBaseline = 'middle';

        // 根据数字位数调整显示
        let displayCount = totalUnreadCount;
        if (totalUnreadCount > 99) {
          displayCount = '99+';
        }

        ctx.fillText(displayCount.toString(), 8, 8);

        // 将canvas转换为图像
        const nativeImage = require('electron').nativeImage.createFromDataURL(canvas.toDataURL());

        // 设置任务栏图标
        mainWindow.setOverlayIcon(nativeImage, `${totalUnreadCount}条未读消息`);
        // 通知渲染进程更新未读消息数量显示
        mainWindow.webContents.send('update-unread-count', totalUnreadCount);
      } catch (error) {
        console.error('创建任务栏图标失败:', error);
      }
    } else {
      // 清除任务栏图标
      mainWindow.setOverlayIcon(null, '');
      mainWindow.webContents.send('update-unread-count', 0);
    }
  }

  // 如果状态发生变化且有新消息，通知渲染进程
  if ((hasNewMessage && !oldStatus) || (hasNewMessage && count !== oldCount)) {
    mainWindow.webContents.send('new-message', tabIndex, urlIndex, count);
  }
});

// 清除新消息状态
ipcMain.on('clear-new-message', (_, tabIndex, urlIndex) => {
  const key = `${tabIndex}_${urlIndex}`;
  messageStatus[key] = false;
  unreadCounts[key] = 0;

  // 更新任务栏图标
  updateTaskbarIcon();
});

// 删除 `BrowserView`
ipcMain.on('remove-browser-view', (_, index, oldArr) => {
  console.log('oldArr: ', oldArr);
  console.log('indexremove: ', index);
  console.log(
    '删除前的views数组:',
    views.map((v) => ({
      url: v.webContents.getURL(),
      id: v.webContents.id,
      partition: v.partitionInfo,
    })),
  );

  // 获取要删除的视图信息
  const removedViewInfo = views[index];
  if (!removedViewInfo) {
    console.error(`无法删除索引 ${index} 的视图，该视图不存在`);
    return;
  }

  // 获取要删除的视图的分区信息
  const partitionToRemove = removedViewInfo.partitionInfo;
  console.log(`将要删除分区为 ${partitionToRemove} 的视图`);

  // 找出所有具有相同分区的视图索引
  const viewIndicesToRemove = views
    .map((view, idx) => ({ idx, partition: view.partitionInfo }))
    .filter((v) => v.partition === partitionToRemove)
    .map((v) => v.idx)
    .sort((a, b) => b - a); // 从大到小排序，以便从后往前删除

  console.log(`找到以下索引的视图需要删除: ${viewIndicesToRemove.join(', ')}`);

  // 从后往前删除视图，避免索引变化导致的问题
  viewIndicesToRemove.forEach((idx) => {
    const viewToRemove = views[idx];
    if (viewToRemove) {
      mainWindow.removeBrowserView(viewToRemove);
      views.splice(idx, 1);
    }
  });

  // 重要：更新tabArr中的索引，使其与views数组同步
  // 创建一个映射，记录每个分区对应的视图索引
  const partitionToViewsMap = {};
  views.forEach((view, idx) => {
    const partition = view.partitionInfo;
    if (!partitionToViewsMap[partition]) {
      partitionToViewsMap[partition] = [];
    }
    partitionToViewsMap[partition].push(idx);
  });

  console.log('分区到视图索引的映射:', partitionToViewsMap);

  // 更新每个标签页中urls的index
  for (const tab of oldArr) {
    const partition = tab.partition;
    const viewIndices = partitionToViewsMap[partition] || [];

    // 确保有足够的视图索引可用
    if (viewIndices.length >= tab.urls.length) {
      // 更新该标签页中每个url的index
      tab.urls.forEach((url, i) => {
        const newIndex = viewIndices[i];
        console.log(`更新标签页 ${tab.index} 的URL ${i} 索引：${url.index} -> ${newIndex}`);
        url.index = newIndex;
      });
    } else {
      console.error(`错误：标签页 ${tab.index} 的分区 ${partition} 没有足够的视图索引`);
    }
  }

  // 保存更新后的标签页数据
  saveTabs(oldArr);

  console.log(
    '删除后的views数组:',
    views.map((v) => ({
      url: v.webContents.getURL(),
      id: v.webContents.id,
      partition: v.partitionInfo,
    })),
  );

  if (views.length === 0) {
    console.log('所有视图已清空');
    currentViewIndex = -1;
  } else {
    // 重新排列剩余视图的索引
    if (currentViewIndex >= views.length) {
      currentViewIndex = 0;
    }
    switchToTab(currentViewIndex);
  }
});

app.whenReady().then(() => {
  electronApp.setAppUserModelId('Whatsapp多开翻译助手');
  // 创建系统托盘图标
  const tray = new Tray(nativeImage.createFromPath(icon));
  // 创建系统托盘菜单
  const contextMenu = Menu.buildFromTemplate([{ label: '退出', type: 'normal', click: () => app.quit() }]);
  tray.setToolTip('Whatsapp多开翻译助手');
  tray.setContextMenu(contextMenu);
  // 双击托盘图标把窗口显示出来
  tray.on('click', () => {
    if (mainWindow) {
      mainWindow.show();
    }
  });

  createWindow();
  // 设置最大监听器数量
  const allWindows = BrowserWindow.getAllWindows();
  allWindows.forEach((window) => {
    window.setMaxListeners(20); // 增加最大监听器数量
  });
  app.on('activate', function () {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', async () => {
  if (process.platform !== 'darwin') {
    // 在退出前确保所有会话数据都被保存
    try {
      // 清理所有消息监听定时器
      for (const key in messageTimers) {
        if (messageTimers[key]) {
          clearInterval(messageTimers[key]);
          delete messageTimers[key];
        }
      }

      // 为每个视图手动触发一次会话数据保存
      for (const view of views) {
        await view.webContents
          .executeJavaScript(
            `
          if (window.electronAPI && window.electronAPI.sessionChanged) {
            const localStorageData = JSON.stringify(localStorage);
            const sessionStorageData = JSON.stringify(sessionStorage);
            window.electronAPI.sessionChanged(localStorageData, sessionStorageData);
          }
        `,
          )
          .catch((err) => console.error('Error saving session before quit:', err));
      }

      // 最后保存所有标签页信息
      await saveTabs();
      console.log('All session data saved before quitting');
    } catch (error) {
      console.error('Error during save before quit:', error);
    }

    app.quit();
  }
});
